/** @preserve
 jSignature v2 "${buildDate}" "${commitID}"
 Copyright (c) 2012 Willow Systems Corp http://willow-systems.com
 Copyright (c) 2010 Brinley Ang http://www.unbolt.net
 MIT License <http://www.opensource.org/licenses/mit-license.php>
 */
;(function() {

	var apinamespace = 'jSignature'

	/**
	 Allows one to delay certain eventual action by setting up a timer for it and allowing one to delay it
	 by "kick"ing it. Sorta like "kick the can down the road"
	 @public
	 @class
	 @param
	 @returns {Type}
	 */
	var KickTimerClass = function(time, callback) {
		var timer;
		this.kick = function() {
			clearTimeout(timer);
			timer = setTimeout(
				callback
				, time
			);
		}
		this.clear = function() {
			clearTimeout(timer);
		}
		return this;
	}

	var PubSubClass = function(context){
		'use strict'
		/*  @preserve
        -----------------------------------------------------------------------------------------------
        JavaScript PubSub library
        2012 (c) Willow Systems Corp (www.willow-systems.com)
        based on Peter Higgins (dante@dojotoolkit.org)
        Loosely based on Dojo publish/subscribe API, limited in scope. Rewritten blindly.
        Original is (c) Dojo Foundation 2004-2010. Released under either AFL or new BSD, see:
        http://dojofoundation.org/license for more information.
        -----------------------------------------------------------------------------------------------
        */
		this.topics = {};
		// here we choose what will be "this" for the called events.
		// if context is defined, it's context. Else, 'this' is this instance of PubSub
		this.context = context ? context : this;
		/**
		 * Allows caller to emit an event and pass arguments to event listeners.
		 * @public
		 * @function
		 * @param topic {String} Name of the channel on which to voice this event
		 * @param **arguments Any number of arguments you want to pass to the listeners of this event.
		 */
		this.publish = function(topic, arg1, arg2, etc) {
			'use strict'
			if (this.topics[topic]) {
				var currentTopic = this.topics[topic]
					, args = Array.prototype.slice.call(arguments, 1)
					, toremove = []
					, torun = []
					, fn
					, i, l
					, pair;

				for (i = 0, l = currentTopic.length; i < l; i++) {
					pair = currentTopic[i]; // this is a [function, once_flag] array
					fn = pair[0];
					if (pair[1] /* 'run once' flag set */){
						pair[0] = function(){};
						toremove.push(i);
					}
					/* don't call the callback right now, it might decide to add or
                     * remove subscribers which will wreak havoc on our index-based
                     * iteration */
					torun.push(fn);
				}
				for (i = 0, l = toremove.length; i < l; i++) {
					currentTopic.splice(toremove[i], 1);
				}
				for (i = 0, l = torun.length; i < l; i++) {
					torun[i].apply(this.context, args);
				}
			}
		}
		/**
		 * Allows listener code to subscribe to channel and be called when data is available
		 * @public
		 * @function
		 * @param topic {String} Name of the channel on which to voice this event
		 * @param callback {Function} Executable (function pointer) that will be ran when event is voiced on this channel.
		 * @param once {Boolean} (optional. False by default) Flag indicating if the function is to be triggered only once.
		 * @returns {Object} A token object that cen be used for unsubscribing.
		 */
		this.subscribe = function(topic, callback, once) {
			'use strict'
			if (!this.topics[topic]) {
				this.topics[topic] = [[callback, once]];
			} else {
				this.topics[topic].push([callback,once]);
			}
			return {
				"topic": topic,
				"callback": callback
			};
		};
		/**
		 * Allows listener code to unsubscribe from a channel
		 * @public
		 * @function
		 * @param token {Object} A token object that was returned by `subscribe` method
		 */
		this.unsubscribe = function(token) {
			if (this.topics[token.topic]) {
				var currentTopic = this.topics[token.topic];

				for (var i = 0, l = currentTopic.length; i < l; i++) {
					if (currentTopic[i] && currentTopic[i][0] === token.callback) {
						currentTopic.splice(i, 1);
					}
				}
			}
		}
	}

/// Returns front, back and "decor" colors derived from element (as jQuery obj)
	function getColors($e){
		var tmp
			, undef
			, frontcolor = $e.css('color')
			, backcolor
			, e = $e[0];

		var toOfDOM = false;
		while(e && !backcolor && !toOfDOM){
			try{
				tmp = $(e).css('background-color');
			} catch (ex) {
				tmp = 'transparent';
			}
			if (tmp !== 'transparent' && tmp !== 'rgba(0, 0, 0, 0)'){
				backcolor = tmp;
			}
			toOfDOM = e.body;
			e = e.parentNode;
		}

		var rgbaregex = /rgb[a]*\((\d+),\s*(\d+),\s*(\d+)/ // modern browsers
			, hexregex = /#([AaBbCcDdEeFf\d]{2})([AaBbCcDdEeFf\d]{2})([AaBbCcDdEeFf\d]{2})/ // IE 8 and less.
			, frontcolorcomponents;

		// Decomposing Front color into R, G, B ints
		tmp = undef;
		tmp = frontcolor.match(rgbaregex);
		if (tmp){
			frontcolorcomponents = {'r':parseInt(tmp[1],10),'g':parseInt(tmp[2],10),'b':parseInt(tmp[3],10)};
		} else {
			tmp = frontcolor.match(hexregex);
			if (tmp) {
				frontcolorcomponents = {'r':parseInt(tmp[1],16),'g':parseInt(tmp[2],16),'b':parseInt(tmp[3],16)};
			}
		}
//		if(!frontcolorcomponents){
//			frontcolorcomponents = {'r':255,'g':255,'b':255}
//		}

		var backcolorcomponents
		// Decomposing back color into R, G, B ints
		if(!backcolor){
			// HIghly unlikely since this means that no background styling was applied to any element from here to top of dom.
			// we'll pick up back color from front color
			if(frontcolorcomponents){
				if (Math.max.apply(null, [frontcolorcomponents.r, frontcolorcomponents.g, frontcolorcomponents.b]) > 127){
					backcolorcomponents = {'r':0,'g':0,'b':0};
				} else {
					backcolorcomponents = {'r':255,'g':255,'b':255};
				}
			} else {
				// arg!!! front color is in format we don't understand (hsl, named colors)
				// Let's just go with white background.
				backcolorcomponents = {'r':255,'g':255,'b':255};
			}
		} else {
			tmp = undef;
			tmp = backcolor.match(rgbaregex);
			if (tmp){
				backcolorcomponents = {'r':parseInt(tmp[1],10),'g':parseInt(tmp[2],10),'b':parseInt(tmp[3],10)};
			} else {
				tmp = backcolor.match(hexregex);
				if (tmp) {
					backcolorcomponents = {'r':parseInt(tmp[1],16),'g':parseInt(tmp[2],16),'b':parseInt(tmp[3],16)};
				}
			}
//			if(!backcolorcomponents){
//				backcolorcomponents = {'r':0,'g':0,'b':0}
//			}
		}

		// Deriving Decor color
		// THis is LAZY!!!! Better way would be to use HSL and adjust luminocity. However, that could be an overkill.

		var toRGBfn = function(o){return 'rgb(' + [o.r, o.g, o.b].join(', ') + ')'}
			, decorcolorcomponents
			, frontcolorbrightness
			, adjusted;

		if (frontcolorcomponents && backcolorcomponents){
			var backcolorbrightness = Math.max.apply(null, [frontcolorcomponents.r, frontcolorcomponents.g, frontcolorcomponents.b]);

			frontcolorbrightness = Math.max.apply(null, [backcolorcomponents.r, backcolorcomponents.g, backcolorcomponents.b]);
			adjusted = Math.round(frontcolorbrightness + (-1 * (frontcolorbrightness - backcolorbrightness) * 0.75)); // "dimming" the difference between pen and back.
			decorcolorcomponents = {'r':adjusted,'g':adjusted,'b':adjusted}; // always shade of gray
		} else if (frontcolorcomponents) {
			frontcolorbrightness = Math.max.apply(null, [frontcolorcomponents.r, frontcolorcomponents.g, frontcolorcomponents.b]);
			var polarity = +1;
			if (frontcolorbrightness > 127){
				polarity = -1;
			}
			// shifting by 25% (64 points on RGB scale)
			adjusted = Math.round(frontcolorbrightness + (polarity * 96)); // "dimming" the pen's color by 75% to get decor color.
			decorcolorcomponents = {'r':adjusted,'g':adjusted,'b':adjusted}; // always shade of gray
		} else {
			decorcolorcomponents = {'r':191,'g':191,'b':191}; // always shade of gray
		}

		return {
			'color': frontcolor
			, 'background-color': backcolorcomponents? toRGBfn(backcolorcomponents) : backcolor
			, 'decor-color': toRGBfn(decorcolorcomponents)
		};
	}

	function Vector(x,y){
		this.x = x;
		this.y = y;
		this.reverse = function(){
			return new this.constructor(
				this.x * -1
				, this.y * -1
			);
		};
		this._length = null;
		this.getLength = function(){
			if (!this._length){
				this._length = Math.sqrt( Math.pow(this.x, 2) + Math.pow(this.y, 2) );
			}
			return this._length;
		};

		var polarity = function (e){
			return Math.round(e / Math.abs(e));
		};
		this.resizeTo = function(length){
			// proportionally changes x,y such that the hypotenuse (vector length) is = new length
			if (this.x === 0 && this.y === 0){
				this._length = 0;
			} else if (this.x === 0){
				this._length = length;
				this.y = length * polarity(this.y);
			} else if(this.y === 0){
				this._length = length;
				this.x = length * polarity(this.x);
			} else {
				var proportion = Math.abs(this.y / this.x)
					, x = Math.sqrt(Math.pow(length, 2) / (1 + Math.pow(proportion, 2)))
					, y = proportion * x;
				this._length = length;
				this.x = x * polarity(this.x);
				this.y = y * polarity(this.y);
			}
			return this;
		};

		/**
		 * Calculates the angle between 'this' vector and another.
		 * @public
		 * @function
		 * @returns {Number} The angle between the two vectors as measured in PI.
		 */
		this.angleTo = function(vectorB) {
			var divisor = this.getLength() * vectorB.getLength();
			if (divisor === 0) {
				return 0;
			} else {
				// JavaScript floating point math is screwed up.
				// because of it, the core of the formula can, on occasion, have values
				// over 1.0 and below -1.0.
				return Math.acos(
					Math.min(
						Math.max(
							( this.x * vectorB.x + this.y * vectorB.y ) / divisor
							, -1.0
						)
						, 1.0
					)
				) / Math.PI;
			}
		};
	}

	function Point(x,y){
		this.x = x;
		this.y = y;

		this.getVectorToCoordinates = function (x, y) {
			return new Vector(x - this.x, y - this.y);
		};
		this.getVectorFromCoordinates = function (x, y) {
			return this.getVectorToCoordinates(x, y).reverse();
		};
		this.getVectorToPoint = function (point) {
			return new Vector(point.x - this.x, point.y - this.y);
		};
		this.getVectorFromPoint = function (point) {
			return this.getVectorToPoint(point).reverse();
		};
	}

	/*
     * About data structure:
     * We don't store / deal with "pictures" this signature capture code captures "vectors"
     *
     * We don't store bitmaps. We store "strokes" as arrays of arrays. (Actually, arrays of objects containing arrays of coordinates.
     *
     * Stroke = mousedown + mousemoved * n (+ mouseup but we don't record that as that was the "end / lack of movement" indicator)
     *
     * Vectors = not classical vectors where numbers indicated shift relative last position. Our vectors are actually coordinates against top left of canvas.
     * 			we could calc the classical vectors, but keeping the the actual coordinates allows us (through Math.max / min)
     * 			to calc the size of resulting drawing very quickly. If we want classical vectors later, we can always get them in backend code.
     *
     * So, the data structure:
     *
     * var data = [
     * 	{ // stroke starts
     * 		x : [101, 98, 57, 43] // x points
     * 		, y : [1, 23, 65, 87] // y points
     * 	} // stroke ends
     * 	, { // stroke starts
     * 		x : [55, 56, 57, 58] // x points
     * 		, y : [101, 97, 54, 4] // y points
     * 	} // stroke ends
     * 	, { // stroke consisting of just a dot
     * 		x : [53] // x points
     * 		, y : [151] // y points
     * 	} // stroke ends
     * ]
     *
     * we don't care or store stroke width (it's canvas-size-relative), color, shadow values. These can be added / changed on whim post-capture.
     *
     */
	function DataEngine(storageObject, context, startStrokeFn, addToStrokeFn, endStrokeFn){
		this.data = storageObject; // we expect this to be an instance of Array
		this.context = context;

		if (storageObject.length){
			// we have data to render
			var numofstrokes = storageObject.length
				, stroke
				, numofpoints;

			for (var i = 0; i < numofstrokes; i++){
				stroke = storageObject[i];
				numofpoints = stroke.x.length;
				startStrokeFn.call(context, stroke);
				for(var j = 1; j < numofpoints; j++){
					addToStrokeFn.call(context, stroke, j);
				}
				endStrokeFn.call(context, stroke);
			}
		}

		this.changed = function(){};

		this.startStrokeFn = startStrokeFn;
		this.addToStrokeFn = addToStrokeFn;
		this.endStrokeFn = endStrokeFn;

		this.inStroke = false;

		this._lastPoint = null;
		this._stroke = null;
		this.startStroke = function(point){
			if(point && typeof(point.x) == "number" && typeof(point.y) == "number"){
				this._stroke = {'x':[point.x], 'y':[point.y]};
				this.data.push(this._stroke);
				this._lastPoint = point;
				this.inStroke = true;
				// 'this' does not work same inside setTimeout(
				var stroke = this._stroke
					, fn = this.startStrokeFn
					, context = this.context;
				setTimeout(
					// some IE's don't support passing args per setTimeout API. Have to create closure every time instead.
					function() {fn.call(context, stroke)}
					, 3
				);
				return point;
			} else {
				return null;
			}
		};
		// that "5" at the very end of this if is important to explain.
		// we do NOT render links between two captured points (in the middle of the stroke) if the distance is shorter than that number.
		// not only do we NOT render it, we also do NOT capture (add) these intermediate points to storage.
		// when clustering of these is too tight, it produces noise on the line, which, because of smoothing, makes lines too curvy.
		// maybe, later, we can expose this as a configurable setting of some sort.
		this.addToStroke = function(point){
			if (this.inStroke &&
				typeof(point.x) === "number" &&
				typeof(point.y) === "number" &&
				// calculates absolute shift in diagonal pixels away from original point
				(Math.abs(point.x - this._lastPoint.x) + Math.abs(point.y - this._lastPoint.y)) > 4
			){
				var positionInStroke = this._stroke.x.length;
				this._stroke.x.push(point.x);
				this._stroke.y.push(point.y);
				this._lastPoint = point;

				var stroke = this._stroke
					, fn = this.addToStrokeFn
					, context = this.context;
				setTimeout(
					// some IE's don't support passing args per setTimeout API. Have to create closure every time instead.
					function() {fn.call(context, stroke, positionInStroke)}
					, 3
				);
				return point;
			} else {
				return null;
			}
		};
		this.endStroke = function(){
			var c = this.inStroke;
			this.inStroke = false;
			this._lastPoint = null;
			if (c){
				var stroke = this._stroke
					, fn = this.endStrokeFn // 'this' does not work same inside setTimeout(
					, context = this.context
					, changedfn = this.changed;
				setTimeout(
					// some IE's don't support passing args per setTimeout API. Have to create closure every time instead.
					function(){
						fn.call(context, stroke);
						changedfn.call(context);
					}
					, 3
				);
				return true;
			} else {
				return null;
			}
		};
	}

	var basicDot = function(ctx, x, y, size){
		var fillStyle = ctx.fillStyle;
		ctx.fillStyle = ctx.strokeStyle;
		ctx.fillRect(x + size / -2 , y + size / -2, size, size);
		ctx.fillStyle = fillStyle;
	}
		, basicLine = function(ctx, startx, starty, endx, endy){
		ctx.beginPath();
		ctx.moveTo(startx, starty);
		ctx.lineTo(endx, endy);
		ctx.closePath();
		ctx.stroke();
	}
		, basicCurve = function(ctx, startx, starty, endx, endy, cp1x, cp1y, cp2x, cp2y){
		ctx.beginPath();
		ctx.moveTo(startx, starty);
		ctx.bezierCurveTo(cp1x, cp1y, cp2x, cp2y, endx, endy);
		ctx.closePath();
		ctx.stroke();
	}
		, strokeStartCallback = function(stroke) {
		// this = jSignatureClass instance
		basicDot(this.canvasContext, stroke.x[0], stroke.y[0], this.settings.lineWidth);
	}
		, strokeAddCallback = function(stroke, positionInStroke){
		// this = jSignatureClass instance

		// Because we are funky this way, here we draw TWO curves.
		// 1. POSSIBLY "this line" - spanning from point right before us, to this latest point.
		// 2. POSSIBLY "prior curve" - spanning from "latest point" to the one before it.

		// Why you ask?
		// long lines (ones with many pixels between them) do not look good when they are part of a large curvy stroke.
		// You know, the jaggedy crocodile spine instead of a pretty, smooth curve. Yuck!
		// We want to approximate pretty curves in-place of those ugly lines.
		// To approximate a very nice curve we need to know the direction of line before and after.
		// Hence, on long lines we actually wait for another point beyond it to come back from
		// mousemoved before we draw this curve.

		// So for "prior curve" to be calc'ed we need 4 points
		// 	A, B, C, D (we are on D now, A is 3 points in the past.)
		// and 3 lines:
		//  pre-line (from points A to B),
		//  this line (from points B to C), (we call it "this" because if it was not yet, it's the only one we can draw for sure.)
		//  post-line (from points C to D) (even through D point is 'current' we don't know how we can draw it yet)
		//
		// Well, actually, we don't need to *know* the point A, just the vector A->B
		var Cpoint = new Point(stroke.x[positionInStroke-1], stroke.y[positionInStroke-1])
			, Dpoint = new Point(stroke.x[positionInStroke], stroke.y[positionInStroke])
			, CDvector = Cpoint.getVectorToPoint(Dpoint);

		// Again, we have a chance here to draw TWO things:
		//  BC Curve (only if it's long, because if it was short, it was drawn by previous callback) and
		//  CD Line (only if it's short)

		// So, let's start with BC curve.
		// if there is only 2 points in stroke array, we don't have "history" long enough to have point B, let alone point A.
		// Falling through to drawing line CD is proper, as that's the only line we have points for.
		if(positionInStroke > 1) {
			// we are here when there are at least 3 points in stroke array.
			var Bpoint = new Point(stroke.x[positionInStroke-2], stroke.y[positionInStroke-2])
				, BCvector = Bpoint.getVectorToPoint(Cpoint)
				, ABvector;
			if(BCvector.getLength() > this.lineCurveThreshold){
				// Yey! Pretty curves, here we come!
				if(positionInStroke > 2) {
					// we are here when at least 4 points in stroke array.
					ABvector = (new Point(stroke.x[positionInStroke-3], stroke.y[positionInStroke-3])).getVectorToPoint(Bpoint);
				} else {
					ABvector = new Vector(0,0);
				}

				var minlenfraction = 0.05
					, maxlen = BCvector.getLength() * 0.35
					, ABCangle = BCvector.angleTo(ABvector.reverse())
					, BCDangle = CDvector.angleTo(BCvector.reverse())
					, BCP1vector = new Vector(ABvector.x + BCvector.x, ABvector.y + BCvector.y).resizeTo(
					Math.max(minlenfraction, ABCangle) * maxlen
				)
					, CCP2vector = (new Vector(BCvector.x + CDvector.x, BCvector.y + CDvector.y)).reverse().resizeTo(
					Math.max(minlenfraction, BCDangle) * maxlen
				);

				basicCurve(
					this.canvasContext
					, Bpoint.x
					, Bpoint.y
					, Cpoint.x
					, Cpoint.y
					, Bpoint.x + BCP1vector.x
					, Bpoint.y + BCP1vector.y
					, Cpoint.x + CCP2vector.x
					, Cpoint.y + CCP2vector.y
				);
			}
		}
		if(CDvector.getLength() <= this.lineCurveThreshold){
			basicLine(
				this.canvasContext
				, Cpoint.x
				, Cpoint.y
				, Dpoint.x
				, Dpoint.y
			);
		}
	}
		, strokeEndCallback = function(stroke){
		// this = jSignatureClass instance

		// Here we tidy up things left unfinished in last strokeAddCallback run.

		// What's POTENTIALLY left unfinished there is the curve between the last points
		// in the stroke, if the len of that line is more than lineCurveThreshold
		// If the last line was shorter than lineCurveThreshold, it was drawn there, and there
		// is nothing for us here to do.
		// We can also be called when there is only one point in the stroke (meaning, the
		// stroke was just a dot), in which case, again, there is nothing for us to do.

		// So for "this curve" to be calc'ed we need 3 points
		// 	A, B, C
		// and 2 lines:
		//  pre-line (from points A to B),
		//  this line (from points B to C)
		// Well, actually, we don't need to *know* the point A, just the vector A->B
		// so, we really need points B, C and AB vector.
		var positionInStroke = stroke.x.length - 1;

		if (positionInStroke > 0){
			// there are at least 2 points in the stroke.we are in business.
			var Cpoint = new Point(stroke.x[positionInStroke], stroke.y[positionInStroke])
				, Bpoint = new Point(stroke.x[positionInStroke-1], stroke.y[positionInStroke-1])
				, BCvector = Bpoint.getVectorToPoint(Cpoint)
				, ABvector;
			if (BCvector.getLength() > this.lineCurveThreshold){
				// yep. This one was left undrawn in prior callback. Have to draw it now.
				if (positionInStroke > 1){
					// we have at least 3 elems in stroke
					ABvector = (new Point(stroke.x[positionInStroke-2], stroke.y[positionInStroke-2])).getVectorToPoint(Bpoint);
					var BCP1vector = new Vector(ABvector.x + BCvector.x, ABvector.y + BCvector.y).resizeTo(BCvector.getLength() / 2);
					basicCurve(
						this.canvasContext
						, Bpoint.x
						, Bpoint.y
						, Cpoint.x
						, Cpoint.y
						, Bpoint.x + BCP1vector.x
						, Bpoint.y + BCP1vector.y
						, Cpoint.x
						, Cpoint.y
					);
				} else {
					// Since there is no AB leg, there is no curve to draw. This line is still "long" but no curve.
					basicLine(
						this.canvasContext
						, Bpoint.x
						, Bpoint.y
						, Cpoint.x
						, Cpoint.y
					);
				}
			}
		}
	}


	/*
    var getDataStats = function(){
        var strokecnt = strokes.length
            , stroke
            , pointid
            , pointcnt
            , x, y
            , maxX = Number.NEGATIVE_INFINITY
            , maxY = Number.NEGATIVE_INFINITY
            , minX = Number.POSITIVE_INFINITY
            , minY = Number.POSITIVE_INFINITY
        for(strokeid = 0; strokeid < strokecnt; strokeid++){
            stroke = strokes[strokeid]
            pointcnt = stroke.length
            for(pointid = 0; pointid < pointcnt; pointid++){
                x = stroke.x[pointid]
                y = stroke.y[pointid]
                if (x > maxX){
                    maxX = x
                } else if (x < minX) {
                    minX = x
                }
                if (y > maxY){
                    maxY = y
                } else if (y < minY) {
                    minY = y
                }
            }
        }
        return {'maxX': maxX, 'minX': minX, 'maxY': maxY, 'minY': minY}
    }
    */

	function conditionallyLinkCanvasResizeToWindowResize(jSignatureInstance, settingsWidth, apinamespace, globalEvents){
		'use strict'
		if ( settingsWidth === 'ratio' || settingsWidth.split('')[settingsWidth.length - 1] === '%' ) {

			this.eventTokens[apinamespace + '.parentresized'] = globalEvents.subscribe(
				apinamespace + '.parentresized'
				, (function(eventTokens, $parent, originalParentWidth, sizeRatio){
					'use strict'

					return function(){
						'use strict'

						var w = $parent.width();
						if (w !== originalParentWidth) {

							// UNsubscribing this particular instance of signature pad only.
							// there is a separate `eventTokens` per each instance of signature pad
							for (var key in eventTokens){
								if (eventTokens.hasOwnProperty(key)) {
									globalEvents.unsubscribe(eventTokens[key]);
									delete eventTokens[key];
								}
							}

							var settings = jSignatureInstance.settings;
							jSignatureInstance.$parent.children().remove();
							for (var key in jSignatureInstance){
								if (jSignatureInstance.hasOwnProperty(key)) {
									delete jSignatureInstance[key];
								}
							}

							// scale data to new signature pad size
							settings.data = (function(data, scale){
								var newData = [];
								var o, i, l, j, m, stroke;
								for ( i = 0, l = data.length; i < l; i++) {
									stroke = data[i];

									o = {'x':[],'y':[]};

									for ( j = 0, m = stroke.x.length; j < m; j++) {
										o.x.push(stroke.x[j] * scale);
										o.y.push(stroke.y[j] * scale);
									}

									newData.push(o);
								}
								return newData;
							})(
								settings.data
								, w * 1.0 / originalParentWidth
							)

							$parent[apinamespace](settings);
						}
					}
				})(
					this.eventTokens
					, this.$parent
					, this.$parent.width()
					, this.canvas.width * 1.0 / this.canvas.height
				)
			)
		}
	};


	function jSignatureClass(parent, options, instanceExtensions) {

		var $parent = this.$parent = $(parent)
			, eventTokens = this.eventTokens = {}
			, events = this.events = new PubSubClass(this)
			, globalEvents = $.fn[apinamespace]('globalEvents')
			, settings = {
			'width' : 'ratio'
			,'height' : 'ratio'
			,'sizeRatio': 4 // only used when height = 'ratio'
			,'color' : '#000'
			,'background-color': '#fff'
			,'decor-color': '#eee'
			,'lineWidth' : 0
			,'minFatFingerCompensation' : -10
			,'showUndoButton': false
			,'readOnly': false
			,'data': []
			,'signatureLine': false
		};

		$.extend(settings, getColors($parent));
		if (options) {
			$.extend(settings, options);
		}
		this.settings = settings;

		for (var extensionName in instanceExtensions){
			if (instanceExtensions.hasOwnProperty(extensionName)) {
				instanceExtensions[extensionName].call(this, extensionName);
			}
		}

		this.events.publish(apinamespace+'.initializing');

		// these, when enabled, will hover above the sig area. Hence we append them to DOM before canvas.
		this.$controlbarUpper = (function(){
			var controlbarstyle = 'padding:0 !important; margin:0 !important;'+
				'width: 100% !important; height: 0 !important; -ms-touch-action: none; touch-action: none;'+
				'margin-top:-1em !important; margin-bottom:1em !important;';
			return $('<div style="'+controlbarstyle+'"></div>').appendTo($parent);
		})();

		this.isCanvasEmulator = false; // will be flipped by initializer when needed.
		var canvas = this.canvas = this.initializeCanvas(settings)
			, $canvas = $(canvas);

		this.$controlbarLower = (function(){
			var controlbarstyle = 'padding:0 !important; margin:0 !important;'+
				'width: 100% !important; height: 0 !important; -ms-touch-action: none; touch-action: none;'+
				'margin-top:-1.5em !important; margin-bottom:1.5em !important; position: relative;';
			return $('<div style="'+controlbarstyle+'"></div>').appendTo($parent);
		})();

		this.canvasContext = canvas.getContext("2d");

		// Most of our exposed API will be looking for this:
		$canvas.data(apinamespace + '.this', this);

		settings.lineWidth = (function(defaultLineWidth, canvasWidth){
			if (!defaultLineWidth){
				return Math.max(
					Math.round(canvasWidth / 400) /*+1 pixel for every extra 300px of width.*/
					, 2 /* minimum line width */
				);
			} else {
				return defaultLineWidth;
			}
		})(settings.lineWidth, canvas.width);

		this.lineCurveThreshold = settings.lineWidth * 3;

		// Add custom class if defined
		if(settings.cssclass && $.trim(settings.cssclass) != "") {
			$canvas.addClass(settings.cssclass);
		}

		// used for shifting the drawing point up on touch devices, so one can see the drawing above the finger.
		this.fatFingerCompensation = 0;

		var movementHandlers = (function(jSignatureInstance) {

				//================================
				// mouse down, move, up handlers:

				// shifts - adjustment values in viewport pixels drived from position of canvas on the page
				var shiftX
					, shiftY
					, setStartValues = function(){
					var tos = $(jSignatureInstance.canvas).offset()
					shiftX = tos.left * -1
					shiftY = tos.top * -1
				}
					, getPointFromEvent = function(e) {
					var firstEvent = (e.changedTouches && e.changedTouches.length > 0 ? e.changedTouches[0] : e);
					// All devices i tried report correct coordinates in pageX,Y
					// Android Chrome 2.3.x, 3.1, 3.2., Opera Mobile,  safari iOS 4.x,
					// Windows: Chrome, FF, IE9, Safari
					// None of that scroll shift calc vs screenXY other sigs do is needed.
					// ... oh, yeah, the "fatFinger.." is for tablets so that people see what they draw.
					return new Point(
						Math.round(firstEvent.pageX + shiftX)
						, Math.round(firstEvent.pageY + shiftY) + jSignatureInstance.fatFingerCompensation
					);
				}
					, timer = new KickTimerClass(
					750
					, function() { jSignatureInstance.dataEngine.endStroke(); }
				);

				this.drawEndHandler = function(e) {
					if (!jSignatureInstance.settings.readOnly) {
						try { e.preventDefault(); } catch (ex) {}
						timer.clear();
						jSignatureInstance.dataEngine.endStroke();
					}
				};
				this.drawStartHandler = function(e) {
					if (!jSignatureInstance.settings.readOnly) {
						e.preventDefault();
						// for performance we cache the offsets
						// we recalc these only at the beginning the stroke
						setStartValues();
						jSignatureInstance.dataEngine.startStroke( getPointFromEvent(e) );
						timer.kick();
					}
				};
				this.drawMoveHandler = function(e) {
					if (!jSignatureInstance.settings.readOnly) {
						e.preventDefault();
						if (!jSignatureInstance.dataEngine.inStroke){
							return;
						}
						jSignatureInstance.dataEngine.addToStroke( getPointFromEvent(e) );
						timer.kick();
					}
				};

				return this;

			}).call( {}, this )

			//
			//================================

		;(function(drawEndHandler, drawStartHandler, drawMoveHandler) {
			var canvas = this.canvas
				, $canvas = $(canvas)
				, undef;
			if (this.isCanvasEmulator){
				$canvas.bind('mousemove.'+apinamespace, drawMoveHandler);
				$canvas.bind('mouseup.'+apinamespace, drawEndHandler);
				$canvas.bind('mousedown.'+apinamespace, drawStartHandler);
			} else {
				var hasEventListener = typeof canvas.addEventListener === 'function';
				this.ontouchstart = function(e) {
					canvas.onmousedown = canvas.onmouseup = canvas.onmousemove = undef;

					this.fatFingerCompensation = (
						settings.minFatFingerCompensation &&
						settings.lineWidth * -3 > settings.minFatFingerCompensation
					) ? settings.lineWidth * -3 : settings.minFatFingerCompensation;

					drawStartHandler(e);

					if (hasEventListener) {
						canvas.addEventListener('touchend', drawEndHandler);
						canvas.addEventListener('touchstart', drawStartHandler);
						canvas.addEventListener('touchmove', drawMoveHandler);
					} else {
						canvas.ontouchend = drawEndHandler;
						canvas.ontouchstart = drawStartHandler;
						canvas.ontouchmove = drawMoveHandler;
					}
				};

				if (hasEventListener) {
					canvas.addEventListener('touchstart', this.ontouchstart);
				} else {
					canvas.ontouchstart = ontouchstart;
				}

				canvas.onmousedown = function(e) {
					if (hasEventListener) {
						canvas.removeEventListener('touchstart', this.ontouchstart);
					} else {
						canvas.ontouchstart = canvas.ontouchend = canvas.ontouchmove = undef;
					}

					drawStartHandler(e);

					canvas.onmousedown = drawStartHandler;
					canvas.onmouseup = drawEndHandler;
					canvas.onmousemove = drawMoveHandler;
				}
				if (window.navigator.msPointerEnabled) {
					canvas.onmspointerdown = drawStartHandler;
					canvas.onmspointerup = drawEndHandler;
					canvas.onmspointermove = drawMoveHandler;
				}
			}
		}).call(
			this
			, movementHandlers.drawEndHandler
			, movementHandlers.drawStartHandler
			, movementHandlers.drawMoveHandler
		)

		//=========================================
		// various event handlers

		// on mouseout + mouseup canvas did not know that mouseUP fired. Continued to draw despite mouse UP.
		// it is bettr than
		// $canvas.bind('mouseout', drawEndHandler)
		// because we don't want to break the stroke where user accidentally gets ouside and wants to get back in quickly.
		eventTokens[apinamespace + '.windowmouseup'] = globalEvents.subscribe(
			apinamespace + '.windowmouseup'
			, movementHandlers.drawEndHandler
		);

		this.events.publish(apinamespace+'.attachingEventHandlers');

		// If we have proportional width, we sign up to events broadcasting "window resized" and checking if
		// parent's width changed. If so, we (1) extract settings + data from current signature pad,
		// (2) remove signature pad from parent, and (3) reinit new signature pad at new size with same settings, (rescaled) data.
		conditionallyLinkCanvasResizeToWindowResize.call(
			this
			, this
			, settings.width.toString(10)
			, apinamespace, globalEvents
		);

		// end of event handlers.
		// ===============================

		this.resetCanvas(settings.data);

		// resetCanvas renders the data on the screen and fires ONE "change" event
		// if there is data. If you have controls that rely on "change" firing
		// attach them to something that runs before this.resetCanvas, like
		// apinamespace+'.attachingEventHandlers' that fires a bit higher.
		this.events.publish(apinamespace+'.initialized');

		return this;
	} // end of initBase

//=========================================================================
// jSignatureClass's methods and supporting fn's

	jSignatureClass.prototype.resetCanvas = function(data, dontClear){
		var canvas = this.canvas
			, settings = this.settings
			, ctx = this.canvasContext
			, isCanvasEmulator = this.isCanvasEmulator
			, cw = canvas.width
			, ch = canvas.height;

		// preparing colors, drawing area
		if (!dontClear){
			ctx.clearRect(0, 0, cw + 30, ch + 30);
		}

		ctx.shadowColor = ctx.fillStyle = settings['background-color']
		if (isCanvasEmulator){
			// FLashCanvas fills with Black by default, covering up the parent div's background
			// hence we refill
			ctx.fillRect(0,0,cw + 30, ch + 30);
		}

		ctx.lineWidth = Math.ceil(parseInt(settings.lineWidth, 10));
		ctx.lineCap = ctx.lineJoin = "round";

		// signature line
		if(settings.signatureLine) {
			if (null != settings['decor-color']) {
				ctx.strokeStyle = settings['decor-color'];
				ctx.shadowOffsetX = 0;
				ctx.shadowOffsetY = 0;
				var lineoffset = Math.round( ch / 5 );
				basicLine(ctx, lineoffset * 1.5, ch - lineoffset, cw - (lineoffset * 1.5), ch - lineoffset);
			}

			if (!isCanvasEmulator){
				ctx.shadowColor = ctx.strokeStyle;
				ctx.shadowOffsetX = ctx.lineWidth * 0.5;
				ctx.shadowOffsetY = ctx.lineWidth * -0.6;
				ctx.shadowBlur = 0;
			}
		}

		ctx.strokeStyle = settings.color;

		// setting up new dataEngine

		if (!data) { data = []; }

		var dataEngine = this.dataEngine = new DataEngine(
			data
			, this
			, strokeStartCallback
			, strokeAddCallback
			, strokeEndCallback
		);

		settings.data = data; // onwindowresize handler uses it, i think.
		$(canvas).data(apinamespace+'.data', data)
			.data(apinamespace+'.settings', settings);

		// we fire "change" event on every change in data.
		// setting this up:
		dataEngine.changed = (function(target, events, apinamespace) {
			'use strict'
			return function() {
				events.publish(apinamespace+'.change');
				target.trigger('change');
			}
		})(this.$parent, this.events, apinamespace);
		// let's trigger change on all data reloads
		dataEngine.changed();

		// import filters will be passing this back as indication of "we rendered"
		return true;
	};

	function initializeCanvasEmulator(canvas){
		if (canvas.getContext){
			return false;
		} else {
			// for cases when jSignature, FlashCanvas is inserted
			// from one window into another (child iframe)
			// 'window' and 'FlashCanvas' may be stuck behind
			// in that other parent window.
			// we need to find it
			var window = canvas.ownerDocument.parentWindow;
			var FC = window.FlashCanvas ?
				canvas.ownerDocument.parentWindow.FlashCanvas :
				(
					typeof FlashCanvas === "undefined" ?
						undefined :
						FlashCanvas
				);

			if (FC) {
				canvas = FC.initElement(canvas);

				var zoom = 1;
				// FlashCanvas uses flash which has this annoying habit of NOT scaling with page zoom.
				// It matches pixel-to-pixel to screen instead.
				// Since we are targeting ONLY IE 7, 8 with FlashCanvas, we will test the zoom only the IE8, IE7 way
				if (window && window.screen && window.screen.deviceXDPI && window.screen.logicalXDPI){
					zoom = window.screen.deviceXDPI * 1.0 / window.screen.logicalXDPI;
				}
				if (zoom !== 1){
					try {
						// We effectively abuse the brokenness of FlashCanvas and force the flash rendering surface to
						// occupy larger pixel dimensions than the wrapping, scaled up DIV and Canvas elems.
						$(canvas).children('object').get(0).resize(Math.ceil(canvas.width * zoom), Math.ceil(canvas.height * zoom));
						// And by applying "scale" transformation we can talk "browser pixels" to FlashCanvas
						// and have it translate the "browser pixels" to "screen pixels"
						canvas.getContext('2d').scale(zoom, zoom);
						// Note to self: don't reuse Canvas element. Repeated "scale" are cumulative.
					} catch (ex) {}
				}
				return true;
			} else {
				throw new Error("Canvas element does not support 2d context. jSignature cannot proceed.");
			}
		}

	}

	jSignatureClass.prototype.initializeCanvas = function(settings) {
		// ===========
		// Init + Sizing code

		var canvas = document.createElement('canvas')
			, $canvas = $(canvas);

		// We cannot work with circular dependency
		if (settings.width === settings.height && settings.height === 'ratio') {
			settings.width = '100%';
		}

		$canvas.css(
			{
				'margin': 0,
				'padding': 0,
				'border': 'none',
				'height': settings.height === 'ratio' || !settings.height ? 1 : settings.height.toString(10),
				'width': settings.width === 'ratio' || !settings.width ? 1 : settings.width.toString(10),
				'-ms-touch-action': 'none',
				'touch-action': 'none',
				'background-color': settings['background-color']
			}
		);

		$canvas.appendTo(this.$parent);

		// we could not do this until canvas is rendered (appended to DOM)
		if (settings.height === 'ratio') {
			$canvas.css(
				'height'
				, Math.round( $canvas.width() / settings.sizeRatio )
			);
		} else if (settings.width === 'ratio') {
			$canvas.css(
				'width'
				, Math.round( $canvas.height() * settings.sizeRatio )
			);
		}

		$canvas.addClass(apinamespace);

		// canvas's drawing area resolution is independent from canvas's size.
		// pixels are just scaled up or down when internal resolution does not
		// match external size. So...

		canvas.width = $canvas.width();
		canvas.height = $canvas.height();

		// Special case Sizing code

		this.isCanvasEmulator = initializeCanvasEmulator(canvas);

		// End of Sizing Code
		// ===========

		// normally select preventer would be short, but
		// Canvas emulator on IE does NOT provide value for Event. Hence this convoluted line.
		canvas.onselectstart = function(e){if(e && e.preventDefault){e.preventDefault()}; if(e && e.stopPropagation){e.stopPropagation()}; return false;};

		return canvas;
	}


	var GlobalJSignatureObjectInitializer = function(window){

		var globalEvents = new PubSubClass();

		// common "window resized" event listener.
		// jSignature instances will subscribe to this chanel.
		// to resize themselves when needed.
		;(function(globalEvents, apinamespace, $, window){
			'use strict'

			var resizetimer
				, runner = function(){
				globalEvents.publish(
					apinamespace + '.parentresized'
				)
			};

			// jSignature knows how to resize its content when its parent is resized
			// window resize is the only way we can catch resize events though...
			$(window).bind('resize.'+apinamespace, function(){
				if (resizetimer) {
					clearTimeout(resizetimer);
				}
				resizetimer = setTimeout(
					runner
					, 500
				);
			})
				// when mouse exists canvas element and "up"s outside, we cannot catch it with
				// callbacks attached to canvas. This catches it outside.
				.bind('mouseup.'+apinamespace, function(e){
					globalEvents.publish(
						apinamespace + '.windowmouseup'
					)
				});

		})(globalEvents, apinamespace, $, window)

		var jSignatureInstanceExtensions = {
			/*
            'exampleExtension':function(extensionName){
                // we are called very early in instance's life.
                // right after the settings are resolved and
                // jSignatureInstance.events is created
                // and right before first ("jSignature.initializing") event is called.
                // You don't really need to manupilate
                // jSignatureInstance directly, just attach
                // a bunch of events to jSignatureInstance.events
                // (look at the source of jSignatureClass to see when these fire)
                // and your special pieces of code will attach by themselves.
                // this function runs every time a new instance is set up.
                // this means every var you create will live only for one instance
                // unless you attach it to something outside, like "window."
                // and pick it up later from there.
                // when globalEvents' events fire, 'this' is globalEvents object
                // when jSignatureInstance's events fire, 'this' is jSignatureInstance
                // Here,
                // this = is new jSignatureClass's instance.
                // The way you COULD approch setting this up is:
                // if you have multistep set up, attach event to "jSignature.initializing"
                // that attaches other events to be fired further lower the init stream.
                // Or, if you know for sure you rely on only one jSignatureInstance's event,
                // just attach to it directly
                this.events.subscribe(
                    // name of the event
                    apinamespace + '.initializing'
                    // event handlers, can pass args too, but in majority of cases,
                    // 'this' which is jSignatureClass object instance pointer is enough to get by.
                    , function(){
                        if (this.settings.hasOwnProperty('non-existent setting category?')) {
                            console.log(extensionName + ' is here')
                        }
                    }
                )
            }
            */
		};

		var exportplugins = {
			'default':function(data){return this.toDataURL()}
			, 'native':function(data){return data}
			, 'image':function(data){
				/*this = canvas elem */
				var imagestring = this.toDataURL();

				if (typeof imagestring === 'string' &&
					imagestring.length > 4 &&
					imagestring.slice(0,5) === 'data:' &&
					imagestring.indexOf(',') !== -1){

					var splitterpos = imagestring.indexOf(',');

					return [
						imagestring.slice(5, splitterpos)
						, imagestring.substr(splitterpos + 1)
					];
				}
				return [];
			}
		};

		// will be part of "importplugins"
		function _renderImageOnCanvas( data, formattype, rerendercallable ) {
			'use strict'
			// #1. Do NOT rely on this. No worky on IE
			//   (url max len + lack of base64 decoder + possibly other issues)
			// #2. This does NOT affect what is captured as "signature" as far as vector data is
			// concerned. This is treated same as "signature line" - i.e. completely ignored
			// the only time you see imported image data exported is if you export as image.

			// we do NOT call rerendercallable here (unlike in other import plugins)
			// because importing image does absolutely nothing to the underlying vector data storage
			// This could be a way to "import" old signatures stored as images
			// This could also be a way to import extra decor into signature area.

			var img = new Image()
				// this = Canvas DOM elem. Not jQuery object. Not Canvas's parent div.
				, c = this;

			img.onload = function () {
				var ctx = c.getContext("2d");
				var oldShadowColor = ctx.shadowColor;
				ctx.shadowColor = "transparent";
				ctx.drawImage(
					img, 0, 0
					, ( img.width < c.width) ? img.width : c.width
					, ( img.height < c.height) ? img.height : c.height
				);
				ctx.shadowColor = oldShadowColor;
			};

			img.src = 'data:' + formattype + ',' + data;
		}

		var importplugins = {
			'native':function(data, formattype, rerendercallable){
				// we expect data as Array of objects of arrays here - whatever 'default' EXPORT plugin spits out.
				// returning Truthy to indicate we are good, all updated.
				rerendercallable( data );
			}
			, 'image': _renderImageOnCanvas
			, 'image/png;base64': _renderImageOnCanvas
			, 'image/jpeg;base64': _renderImageOnCanvas
			, 'image/jpg;base64': _renderImageOnCanvas
		};

		function _clearDrawingArea( data, dontClear ) {
			this.find('canvas.'+apinamespace)
				.add(this.filter('canvas.'+apinamespace))
				.data(apinamespace+'.this').resetCanvas( data, dontClear );
			return this;
		}

		function _setDrawingData( data, formattype ) {
			var undef;

			if (formattype === undef && typeof data === 'string' && data.substr(0,5) === 'data:') {
				formattype = data.slice(5).split(',')[0];
				// 5 chars of "data:" + mimetype len + 1 "," char = all skipped.
				data = data.slice(6 + formattype.length);
				if (formattype === data) {
					return;
				}
			}

			var $canvas = this.find('canvas.'+apinamespace).add(this.filter('canvas.'+apinamespace));

			if (!importplugins.hasOwnProperty(formattype)) {
				throw new Error(apinamespace + " is unable to find import plugin with for format '"+ String(formattype) +"'");
			} else if ($canvas.length !== 0) {
				importplugins[formattype].call(
					$canvas[0]
					, data
					, formattype
					, (function(jSignatureInstance){
						return function(){ return jSignatureInstance.resetCanvas.apply(jSignatureInstance, arguments) }
					})($canvas.data(apinamespace+'.this'))
				);
			}

			return this;
		}

		var elementIsOrphan = function(e){
			var topOfDOM = false;
			e = e.parentNode;
			while (e && !topOfDOM){
				topOfDOM = e.body;
				e = e.parentNode;
			}
			return !topOfDOM;
		}

		//These are exposed as methods under $obj.jSignature('methodname', *args)
		var plugins = {'export':exportplugins, 'import':importplugins, 'instance': jSignatureInstanceExtensions}
			, methods = {
			'init' : function( options ) {
				return this.each( function() {
					if (!elementIsOrphan(this)) {
						new jSignatureClass(this, options, jSignatureInstanceExtensions);
					}
				})
			}
			, 'destroy': function() {
				return this.each(function() {
					if(!elementIsOrphan(this)) {
						var sig = $(this).find('canvas').data(apinamespace + '.this');
						if(sig) {
							sig.$controlbarLower.remove();
							sig.$controlbarUpper.remove();
							$(sig.canvas).remove();
							for (var e in sig.eventTokens){
								if (sig.eventTokens.hasOwnProperty(e)){
									globalEvents.unsubscribe(sig.eventTokens[e]);
								}
							}
						}
					}
				});
			}
			, 'getSettings' : function() {
				return this.find('canvas.'+apinamespace)
					.add(this.filter('canvas.'+apinamespace))
					.data(apinamespace+'.this').settings;
			}
			, 'isModified' : function() {
				return this.find('canvas.'+apinamespace)
					.add(this.filter('canvas.'+apinamespace))
					.data(apinamespace+'.this')
					.dataEngine
					._stroke !== null;
			}
			, 'updateSetting' : function(param, val, forFuture) {
				var $canvas = this.find('canvas.'+apinamespace)
					.add(this.filter('canvas.'+apinamespace))
					.data(apinamespace+'.this');
				$canvas.settings[param] = val;
				$canvas.resetCanvas(( forFuture ? null : $canvas.settings.data ), true);
				return $canvas.settings[param];
			}
			// around since v1
			, 'clear' : _clearDrawingArea
			// was mistakenly introduced instead of 'clear' in v2
			, 'reset' : _clearDrawingArea
			, 'addPlugin' : function(pluginType, pluginName, callable){
				if (plugins.hasOwnProperty(pluginType)){
					plugins[pluginType][pluginName] = callable;
				}
				return this;
			}
			, 'listPlugins' : function(pluginType){
				var answer = [];
				if (plugins.hasOwnProperty(pluginType)){
					var o = plugins[pluginType];
					for (var k in o){
						if (o.hasOwnProperty(k)){
							answer.push(k);
						}
					}
				}
				return answer;
			}
			, 'getData' : function( formattype ) {
				var undef, $canvas=this.find('canvas.'+apinamespace).add(this.filter('canvas.'+apinamespace));
				if (formattype === undef) {
					formattype = 'default';
				}
				if ($canvas.length !== 0 && exportplugins.hasOwnProperty(formattype)){
					return exportplugins[formattype].call(
						$canvas.get(0) // canvas dom elem
						, $canvas.data(apinamespace+'.data') // raw signature data as array of objects of arrays
						, $canvas.data(apinamespace+'.settings')
					);
				}
			}
			// around since v1. Took only one arg - data-url-formatted string with (likely png of) signature image
			, 'importData' : _setDrawingData
			// was mistakenly introduced instead of 'importData' in v2
			, 'setData' : _setDrawingData
			// this is one and same instance for all jSignature.
			, 'globalEvents' : function(){return globalEvents}
			, 'disable' : function() {
				this.find("input").attr("disabled", 1);
				this.find('canvas.'+apinamespace)
					.addClass("disabled")
					.data(apinamespace+'.this')
					.settings
					.readOnly=true;
			}
			, 'enable' : function() {
				this.find("input").removeAttr("disabled");
				this.find('canvas.'+apinamespace)
					.removeClass("disabled")
					.data(apinamespace+'.this')
					.settings
					.readOnly=false;
			}
			// there will be a separate one for each jSignature instance.
			, 'events' : function() {
				return this.find('canvas.'+apinamespace)
					.add(this.filter('canvas.'+apinamespace))
					.data(apinamespace+'.this').events;
			}
		} // end of methods declaration.

		$.fn[apinamespace] = function(method) {
			'use strict'
			if ( !method || typeof method === 'object' ) {
				return methods.init.apply( this, arguments );
			} else if ( typeof method === 'string' && methods[method] ) {
				return methods[method].apply( this, Array.prototype.slice.call( arguments, 1 ));
			} else {
				$.error( 'Method ' +  String(method) + ' does not exist on jQuery.' + apinamespace );
			}
		}

	} // end of GlobalJSignatureObjectInitializer

	GlobalJSignatureObjectInitializer(window)

})();